package com.pkx.guide.timing;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.pkx.guide.common.util.DateUtils;
import com.pkx.guide.common.util.StringUtils;
import com.pkx.guide.fcms.service.FcmsPlayService;
import com.pkx.guide.holidays.entity.THolidaysDate;
import com.pkx.guide.holidays.service.THolidaysDateService;
import com.pkx.guide.info.entity.ProducerQest;
import com.pkx.guide.info.entity.TInfoGuide;
import com.pkx.guide.info.entity.TInfoGuidePublish;
import com.pkx.guide.info.service.TInfoGuidePublishService;
import com.pkx.guide.info.service.TInfoGuideService;
import com.pkx.guide.qianfeng.service.QianFengPlayLedService;
import com.sansi.tools.RetrunData;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 乾丰 自动触发任务
 *
 * @Author : YangLe
 * @create 2025/8/28 17:19
 */
@Slf4j
@Component
public class QianFengAutomatic {



    // 依赖注入（假设已通过Spring注入）
    // 修改为构造函数注入
    @Resource
    private  TInfoGuidePublishService tInfoGuidePublishService;

//    public QianFengAutomatic(TInfoGuidePublishService tInfoGuidePublishService) {
//        this.tInfoGuidePublishService = tInfoGuidePublishService;
//    }

//    @Resource
//    private TInfoNetworkConfigService infoNetworkConfigService;
    @Resource
    private TInfoGuideService guideService;

    @Resource
    private FcmsPlayService fcmsPlayService;

//    @Resource
//    private RedisTemplate<String, Object> redisTemplate;
private final THolidaysDateService tHolidaysDateService;

    @Autowired
    public QianFengAutomatic(THolidaysDateService tHolidaysDateService) {
        this.tHolidaysDateService = tHolidaysDateService;
    }

    /**
     * 每10秒执行一次：仅在节假日、调休日、周六周日检查设备状态，离线则发布
     */
    // 1. 类级别定义统一的格式器（关键：避免局部重定义导致混乱）
    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    private static final DateTimeFormatter DATE_TIME_FORMATTER_FULL = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    private static final DateTimeFormatter DATE_TIME_FORMATTER_DATE_ONLY = DateTimeFormatter.ISO_LOCAL_DATE;
    private static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern("HH:mm");



    @Resource
    private QianFengPlayLedService qianFengPlayLedService;

//        @Scheduled(
//            cron = "0 10,20,30,40,50,00 * * * ?"
//    )
//    @Scheduled(
//            cron = "0 * * * * ?"
//    )

    /**
     * 定时发布 每5分钟运行一次
     */
    @Scheduled(cron = "0 0,05,10,15,20,25,30,35,40,45,50,55 * * * ?")
//    @Scheduled(cron = "0 * * * * ?")
    public  void autoPublishByDate() {
    // 添加空值检查
    if (tInfoGuidePublishService == null) {
        log.error("TInfoGuidePublishService 未正确注入");
        return;
    }

    try {
                // 执行核心发布逻辑
                executePublishLogic();
                log.info("自动发布执行成功");
            } catch (Exception e) {
                log.error("自动发布执行异常", e);
        }
    }
    enum DateType {
        HOLIDAY,    // 节假日（放假）- 最高优先级
        ADJUST_WORK,// 调休上班日（含周六日调休，按工作日处理）
        WEEKEND,    // 周六日（非节假日/非调休，按节假日处理）
        WORKDAY     // 普通工作日 - 最低优先级
    }

    /**
     * 提取核心发布逻辑为单独方法，使代码结构更清晰
     */
    private void executePublishLogic() throws Exception {
        try {

            log.error("开始乾丰自动发布检查（节假日/调休/周末专用）");
            LocalDateTime now = LocalDateTime.now();
            LocalDate today = now.toLocalDate();
            String todayDateStr = today.format(DATE_FORMATTER);
            LocalDateTime currentTime = LocalDateTime.now();
            log.info("当前完整时间：{}", now.format(DATE_TIME_FORMATTER_FULL));
            log.info("当前日期：{}，当前时间（分钟级）：{}", todayDateStr, currentTime.format(TIME_FORMATTER));

            //            // 从数据库查询所有任务配置

//            boolean shouldExecute = false;
//            LocalDate today1 = now.toLocalDate();
//            ArrayList<TInfoGuidePublish> tInfoGuidePublishes = new ArrayList<>();
//            for (TInfoGuidePublish task : basePublishList2) {
//                String timeStr = task.getStartTimeScale();
//                if (timeStr == null || timeStr.trim().isEmpty()) {
//                    continue; // 跳过空时间任务
//                }
//
//                try {
//                    LocalTime taskTimeHM = LocalTime.parse(timeStr, DateTimeFormatter.ofPattern("HH:mm"));
//                    log.error("任务时间：{}", taskTimeHM);
//                    LocalDate taskDate = today1;
//                    LocalDateTime taskTime = LocalDateTime.of(taskDate, taskTimeHM);
//
//                    // 截断当前时间到分钟级，确保精度匹配
//                    LocalDateTime nowTruncated = now.truncatedTo(ChronoUnit.MINUTES);
//                    if (taskTime.isEqual(nowTruncated)) {
//                        shouldExecute = true;
//                        tInfoGuidePublishes.add(task); // 添加所有符合条件的任务
//                        log.info("找到当前分钟内的任务，任务时间: {}", taskTime.format(DATE_TIME_FORMATTER_FULL));
//                        // 不要用break，继续检查后续任务
//                    }
//                } catch (Exception e) {
//                    log.error("解析任务时间出错，任务ID: {}", task.getId(), e);
//                }
//            }
//
//           // 遍历完所有任务后，再判断是否有符合条件的任务
//            if (!shouldExecute) {
//                log.info("没有需要执行的自动发布任务");
//                return; // 此时才结束方法
//            }
//
//            log.error("需要执行的任务列表：{}", tInfoGuidePublishes);
//           log.error("需要执行的任务数量：{}", tInfoGuidePublishes.size());

            // 2. 日期类型判定（节假日＞调休日＞周六日＞工作日）
            DateType todayType = DateType.WORKDAY;
            List<THolidaysDate> holidaysList = getHolidaysListFromRedis();
            log.info("从Redis获取到节假日数据：{}", holidaysList);

            // 2.1 判定是否为节假日或调休日
            if (holidaysList != null && !holidaysList.isEmpty()) {
                for (THolidaysDate holiday : holidaysList) {
                    // 防御：跳过无效节假日数据（起止时间为空）
                    if (holiday.getStartTime() == null || holiday.getEndTime() == null) {
                        log.warn("节假日数据无效（起止时间为空），跳过：{}", holiday);
                        continue;
                    }

                    // 判定是否为节假日（在起止区间内）
                    if (todayDateStr.compareTo(holiday.getStartTime()) >= 0 && todayDateStr.compareTo(holiday.getEndTime()) <= 0) {
                        todayType = DateType.HOLIDAY;
                        log.info("今日在节假日区间[{} - {}]内，判定为：{}",
                                holiday.getStartTime(), holiday.getEndTime(), todayType);
                        break; // 节假日优先级最高，终止循环
                    }

                    // 判定是否为调休上班日
                    String adjustedTime = holiday.getAdjustedTime();
                    if (adjustedTime != null && !adjustedTime.trim().isEmpty()) {
                        String[] adjustedDateStrs = adjustedTime.split(",");
                        for (String dateStr : adjustedDateStrs) {
                            String adjustedDate = extractDateFromDateTimeStr(dateStr);
                            if (todayDateStr.equals(adjustedDate)) {
                                todayType = DateType.ADJUST_WORK;
                                log.info("今日为调休上班日[{}]，判定为：{}", adjustedDate, todayType);
                                break;
                            }
                        }
                        if (todayType == DateType.ADJUST_WORK) break; // 调休日优先级次之，终止循环
                    }
                }
            } else {
                log.info("无节假日数据，直接判定为默认类型：{}", todayType);
            }

            // 2.2 判定是否为周六日（仅当未判定为节假日/调休日时）
            if (todayType == DateType.WORKDAY) {
                DayOfWeek dayOfWeek = today.getDayOfWeek();
                if (dayOfWeek == DayOfWeek.SATURDAY || dayOfWeek == DayOfWeek.SUNDAY) {
                    todayType = DateType.WEEKEND;
                    log.info("今日为{}，判定为：{}", dayOfWeek, todayType);
                } else {
                    log.info("今日为{}，保持默认判定：{}", dayOfWeek, todayType);
                }
            }

            log.info("最终判定 - 今日日期类型：{}，日期：{}", todayType, todayDateStr);

            // 3. 构建查询条件（复用，减少冗余）
            LambdaQueryWrapper<TInfoGuidePublish> queryWrapper = new LambdaQueryWrapper<>();

// 设置查询条件：delFlg = 0 AND state = 0 AND modeType = 0
            queryWrapper.eq(TInfoGuidePublish::getDelFlg, 0)    // 等价于 query.setDelFlg(0)
                    .eq(TInfoGuidePublish::getState, 0)     // 等价于 query.setState(0)
                    .eq(TInfoGuidePublish::getModeType, 0); // 等价于 query.setModeType(0)

            List<TInfoGuidePublish> targetTasks = new ArrayList<>();

            // 4. 按日期类型查询并筛选任务
            switch (todayType) {
                case HOLIDAY:
                case WEEKEND:
                    // 节假日/周六日：查询 holidays=0 的任务，无需时间筛选（按原逻辑）
                    queryWrapper.eq(TInfoGuidePublish::getHolidays,0);
                    targetTasks = tInfoGuidePublishService.list(queryWrapper);

                    log.info("{} 符合基础条件的任务总数：{}", todayType, targetTasks.size());
                    break;

                case ADJUST_WORK:
                case WORKDAY:
                    // 调休日/普通工作日：查询 holidays=1 的任务，需按当前时间筛选
                    queryWrapper.eq(TInfoGuidePublish::getHolidays,1);
                    List<TInfoGuidePublish> workTasks = tInfoGuidePublishService.list(queryWrapper);
                    log.info("{} 符合基础条件的任务总数：{}", todayType, workTasks.size());
                    // 执行时间筛选（匹配当前分钟级时间）
                    targetTasks = filterTasksByTime(workTasks, todayDateStr, currentTime);
                    log.info("{} 经过时间筛选后的任务数量：{}", todayType, targetTasks.size());
                    break;
            }

            // 5. 执行任务发布（空任务列表直接返回，避免无效操作）
            if (targetTasks.isEmpty()) {
                log.info("{} 无符合最终条件的任务，无需执行发布", todayType);
                return;
            }

            log.error("进入 {} 的自动发布流程，待发布任务数：{}", todayType, targetTasks.size());
            extracted(targetTasks);
            log.error("{} 的自动发布流程执行完成", todayType);

        } catch (Exception e) {
            log.error("乾丰自动发布逻辑执行异常", e);
        }
            // 判断今天周六日
//            List<THolidaysDate> holidaysList = getHolidaysListFromRedis();
//
//            log.info("节假日数据：{}", holidaysList);
//            // 修复空指针判断逻辑（先判断null再判断空）
//            if (holidaysList != null && !holidaysList.isEmpty()) {
//                for (THolidaysDate tHolidaysDate : holidaysList) {
//                    String startTime = tHolidaysDate.getStartTime();
//                    String endTime = tHolidaysDate.getEndTime();
//                    // 判断今天是不是在startTime和endTime之间
//                    if (todayDateStr.compareTo(startTime) >= 0 && todayDateStr.compareTo(endTime) <= 0) {
//                        strings.add(todayDateStr);
//                    }
//
//                    // 判断今天是不是调休
//                    String adjustedTime = tHolidaysDate.getAdjustedTime();
//                    // 修复空字符串判断逻辑
//                    if (adjustedTime != null && !adjustedTime.isEmpty()) {
//                        // 处理逗号分隔的多个调休日期
//                        String[] adjustedDateTimeStrs = adjustedTime.split(",");
//                        for (String dateTimeStr : adjustedDateTimeStrs) {
//                            String adjustedDate = extractDateFromDateTimeStr(dateTimeStr);
//                            // 避免重复添加
//                            if (!strings.contains(adjustedDate)) {
//                                strings.add(adjustedDate);
//                            }
//                        }
//                    }
//                }
//
//                for (String string : strings) {
//                    if (string.equals(todayDateStr)) {
//                        // 查询符合条件的任务
//                        TInfoGuidePublish tInfoGuidePublish = new TInfoGuidePublish();
//                        tInfoGuidePublish.setDelFlg(0);
//                        tInfoGuidePublish.setState(0);
//                        tInfoGuidePublish.setModeType(0);
//                        tInfoGuidePublish.setHolidays(0);
//                        List<TInfoGuidePublish> basePublishList = tInfoGuidePublishService.listByEntity(tInfoGuidePublish);
//
//                        log.info("符合节假日的总数: {}", basePublishList.size());
//
//                        // 筛选任务
////                        List<TInfoGuidePublish> filteredList = filterTasksByTime(basePublishList, todayDateStr, currentTime);
//                        log.info("符合节假日经过时间筛选后的任务数量：{}", basePublishList.size());
//
//                        log.error("进入执行1的自动发布");
//                        extracted(basePublishList);
//                    }
//                }
//            }
//
//
//            if (today.getDayOfWeek() == DayOfWeek.SATURDAY || today.getDayOfWeek() == DayOfWeek.SUNDAY) {
//                if (!strings.contains(todayDateStr)) {
//                    strings.add(todayDateStr);
//                    log.info("今天是周六周末：{}", todayDateStr);
//                }
//            }
//            log.info("今天是周六日，符合周末的日期：{}", strings);
//            log.info("今天是周六日：{}", todayDateStr);
//            for (String string : strings) {
//            // 处理非节假日情况
//            if (!string.equals(todayDateStr)) {
//
//                TInfoGuidePublish tInfoGuidePublish = new TInfoGuidePublish();
//                tInfoGuidePublish.setDelFlg(0);
//                tInfoGuidePublish.setState(0);
//                tInfoGuidePublish.setModeType(0);
//                tInfoGuidePublish.setHolidays(1);
//                List<TInfoGuidePublish> basePublishList = tInfoGuidePublishService.listByEntity(tInfoGuidePublish);
//
//
//                log.info("不符合节假日的总数: {}", basePublishList.size());
//
//                List<TInfoGuidePublish> filteredList = filterTasksByTime(basePublishList, todayDateStr, currentTime);
//                log.info("不符合节假日,经过时间筛选后的任务数量：{}", filteredList.size());
//                log.error("进入执行2的自动发布");
//                extracted(filteredList);
//            } else {
//
//                    log.info("今天是周六日，符合周末的日期：{}", string);
//
//                        log.error("周六日");
//                        TInfoGuidePublish tInfoGuidePublish = new TInfoGuidePublish();
//                        tInfoGuidePublish.setDelFlg(0);
//                        tInfoGuidePublish.setState(0);
//                        tInfoGuidePublish.setModeType(0);
//                        tInfoGuidePublish.setHolidays(0);
//                        List<TInfoGuidePublish> basePublishList = tInfoGuidePublishService.listByEntity(tInfoGuidePublish);
//                        if (basePublishList.isEmpty()){
//                            log.error("没有需要发布的任务");
//                        }
//                        log.info("符合周六日的总数: {}", basePublishList.size());
////                        List<TInfoGuidePublish> filteredList = filterTasksByTime(basePublishList, todayDateStr, currentTime);
//                        log.info("符合周六日经过时间筛选后的任务数量：{}", basePublishList.size());
//                        log.error("进入执行3的自动发布");
//                        extracted(basePublishList);
//                }
//            }

    }


    private void extracted(List<TInfoGuidePublish> filteredList) throws Exception {
        log.error("开始处理任务");
        ObjectMapper objectMapper = new ObjectMapper();

        for (TInfoGuidePublish task : filteredList) {
            // 5.2 解析发布详情（IP列表）
//            String publishDetail = task.getPublishDetail();
//            if (StringUtils.isEmpty(publishDetail)) {
//                log.warn("任务[{}]：发布详情为空，跳过处理", task.getId());
//                continue;
//            }
            // 三四发布
            if (task.getGuideType()==0){
                // 5.3 检查设备状态并发布
                checkSansiDeviceAndPublish(task);
                log.info("三四发布任务[{}]：发布成功", task.getId());
            }
            // 乾丰发布
            if (task.getGuideType()==1){
                checkQianFengDeviceAndPublish(task);
                log.info("乾丰发布任务[{}]：发布成功", task.getId());
            }


        }
    }
//    @Resource
//    private DynamicTaskManager dynamicTaskManager;
    public void checkSansiDeviceAndPublish(TInfoGuidePublish tInfoGuidePublish) {
        if (tInfoGuidePublish == null){
            throw new IllegalArgumentException("参数为空");
        }
        tInfoGuidePublish.setPublishTime(DateUtils.getCurrentTimeStr());
        // 查询情报板信息
        TInfoGuide guide = guideService.selectById(tInfoGuidePublish.getGuideId());
        if (guide == null){
            throw new RuntimeException("未查询到情报板信息");
        }

        RetrunData result = fcmsPlayService.fcmsActivePlayList(guide, tInfoGuidePublish.getPlayListName());
        log.info("手动发布结果：{}", JSONObject.toJSONString(result));
    }


    /**
     * 子方法：筛选“任务时间晚于当前时间”的任务
     */
    private List<TInfoGuidePublish> filterTasksByTime(List<TInfoGuidePublish> baseList, String todayDateStr, LocalDateTime currentTime) {
        List<TInfoGuidePublish> resultZi = new ArrayList<>();
        List<TInfoGuidePublish> tInfoGuidePublisheShou = new ArrayList<>();
        log.error(" 对自动任务开始筛选 filterTasksByTime数量 "+baseList.size());
        for (TInfoGuidePublish task : baseList) {
            log.error("task:{}",task);
            String startTimeScale = task.getStartTimeScale();
            String endTimeScale = task.getEndTimeScale();
            if (StringUtils.isEmpty(startTimeScale)) {
                log.warn("任务[{}]：startTimeScale为空，跳过筛选", task.getId());
                continue;
            }
            if (StringUtils.isEmpty(endTimeScale)) {
                log.warn("任务[{}]：endTimeScale为空，跳过筛选", task.getId());
                continue;
            }

            try {
                // 补全时间为 yyyy-MM-dd HH:mm:ss 格式
//                String completeTime = 补全时间(startTimeScale);
//                String completeEndTime = 补全时间(endTimeScale);
//                String fullTimeStr = todayDateStr + " " + completeTime;
//                String fullTimeEnd = todayDateStr + " " + completeEndTime;
//                // 用完整格式器解析（此时fullTimeStr已确保是 HH:mm:ss 格式）
//                LocalDateTime taskTime = LocalDateTime.parse(fullTimeStr, DATE_TIME_FORMATTER_FULL)
//                       ;
//                LocalDateTime endTime = LocalDateTime.parse(fullTimeEnd, DATE_TIME_FORMATTER_FULL);
//
//                // 截断时间到分钟级（避免秒/纳秒差异导致匹配失败）
//                LocalDateTime taskTimeTruncated = taskTime.truncatedTo(ChronoUnit.MINUTES);
//                LocalDateTime currentTimeTruncated = currentTime.truncatedTo(ChronoUnit.MINUTES);

//          // 仅当任务开始时间（分钟级）等于当前时间（分钟级）时才符合条件
//                if (taskTimeTruncated.isEqual(currentTimeTruncated)) {
//                    result.add(task);
//                    log.debug("任务[{}]：符合时间条件（当前时间：{} == 开始时间：{}）",
//                            task.getId(),
//                            currentTimeTruncated.format(DATE_TIME_FORMATTER_FULL),
//                            taskTimeTruncated.format(DATE_TIME_FORMATTER_FULL));
//                }
//
// 补全时间（假设补全后格式为 HH:mm:ss，如 "00:00" 补全为 "00:00:00"）
                String completeTime = 补全时间(startTimeScale);
                String completeEndTime = 补全时间(endTimeScale);

// 拼接完整的日期时间字符串（如 "2025-11-10 08:30:00"）
                String fullTimeStr = todayDateStr + " " + completeTime;
                String fullTimeEnd = todayDateStr + " " + completeEndTime;

// 解析为 LocalDateTime 对象
                LocalDateTime taskTime = LocalDateTime.parse(fullTimeStr, DATE_TIME_FORMATTER_FULL);
                LocalDateTime endTime = LocalDateTime.parse(fullTimeEnd, DATE_TIME_FORMATTER_FULL);

// 截断所有时间到分钟级（去除秒和纳秒，统一判断粒度）
                LocalDateTime taskTimeTruncated = taskTime.truncatedTo(ChronoUnit.MINUTES); // 开始时间（分钟级）
                LocalDateTime endTimeTruncated = endTime.truncatedTo(ChronoUnit.MINUTES);   // 结束时间（分钟级）
                LocalDateTime currentTimeTruncated = currentTime.truncatedTo(ChronoUnit.MINUTES); // 当前时间（分钟级）

                // 判断当前时间是否在 [开始时间, 结束时间] 范围内（包含边界）
                // 判断当前时间是否在 [开始时间, 结束时间] 范围内（包含边界）
                if ((currentTimeTruncated.isAfter(taskTimeTruncated) || currentTimeTruncated.isEqual(taskTimeTruncated))
                        && (currentTimeTruncated.isBefore(endTimeTruncated))) {//|| currentTimeTruncated.isEqual(endTimeTruncated)

                    // 符合时间范围，添加到结果集

                    log.error("任务[{}]符合时间范围：开始时间[{}] <= 当前时间[{}] <= 结束时间[{}]",
                            task.getId(),
                            taskTimeTruncated.format(DATE_TIME_FORMATTER_FULL),
                            currentTimeTruncated.format(DATE_TIME_FORMATTER_FULL),
                            endTimeTruncated.format(DATE_TIME_FORMATTER_FULL));


                    //查询满足今天的所有时间的内容
                    LambdaQueryWrapper<TInfoGuidePublish> lambdaQueryWrapper = new QueryWrapper<TInfoGuidePublish>().lambda();
                    lambdaQueryWrapper.eq(TInfoGuidePublish::getDelFlg, 0);
                    lambdaQueryWrapper.eq(TInfoGuidePublish::getState, 0);
                    lambdaQueryWrapper.eq(TInfoGuidePublish::getModeType, 1);
                    lambdaQueryWrapper.gt(TInfoGuidePublish::getCreateTime, taskTimeTruncated.format(DATE_TIME_FORMATTER_FULL));
                    lambdaQueryWrapper.lt(TInfoGuidePublish::getCreateTime, endTimeTruncated.format(DATE_TIME_FORMATTER_FULL));

                    String sqlSegment = lambdaQueryWrapper.getSqlSegment();
                    System.out.println("SQL 条件片段：" + sqlSegment);

                    List<TInfoGuidePublish> basePublishList = tInfoGuidePublishService.list(lambdaQueryWrapper);
                    JSONArray originalPublishDetail = JSONArray.parseArray(task.getPublishDetail());
                   ;
                    for (int i = 0; i < originalPublishDetail.size(); i++) {
                        JSONObject obj = originalPublishDetail.getJSONObject(i);
                        String ip = obj.getString("ip");
                        log.error("当前自动任务ip: {}，检索其是否存在手动任务", ip);

                        for (TInfoGuidePublish infoGuidePublish : basePublishList) {
                            boolean found = false;
                            log.error("infoGuide:{}", basePublishList);
                            JSONArray originalPublishDetails = com.alibaba.fastjson.JSONArray.parseArray(infoGuidePublish.getPublishDetail());
                            for (int j = 0; j < originalPublishDetails.size(); j++) {
                                JSONObject object = originalPublishDetail.getJSONObject(j);
                                String objString = object.getString("ip");
                                String prgid = object.getString("prgid");
                                if (ip.equals(objString)) {
                                    if (found) {
                                        break;
                                    }
                                    tInfoGuidePublisheShou.add(infoGuidePublish);// 加手动
                                    log.error("找到高优先级手动任务: {},{},{}", infoGuidePublish.getId(),objString,  prgid);
                                    found = true;
                                    break;
                                }
                            }
                        }
                    }

                       if (tInfoGuidePublisheShou.isEmpty()){
                           log.error("未找到 手动任务 执行自动");
                           resultZi.add(task);   //加自动
                       }


                    //log.error("basePublishList数量" + basePublishList.size());
                    //log.error("basePublishList:{}", basePublishList);

                } else {
                    log.error("任务[{}]不符合时间范围：当前时间[{}]不在[{} - {}]之间",
                            task.getId(),
                            currentTimeTruncated.format(DATE_TIME_FORMATTER_FULL),
                            taskTimeTruncated.format(DATE_TIME_FORMATTER_FULL),
                            endTimeTruncated.format(DATE_TIME_FORMATTER_FULL));
                }

//                    TInfoGuidePublish tInfoGuidePublish = new TInfoGuidePublish();
//                    tInfoGuidePublish.setDelFlg(0);
//                    tInfoGuidePublish.setState(0);
//                    tInfoGuidePublish.setModeType(1);
//                    List<TInfoGuidePublish> basePublishList = tInfoGuidePublishService.listByEntity(tInfoGuidePublish);
//                    for (TInfoGuidePublish infoGuidePublish : basePublishList) {
//                        String publishTime = infoGuidePublish.getPublishTime();
//                        String times = 补全时间(publishTime);
//                        LocalDateTime taskTimes= LocalDateTime.parse(times, DATE_TIME_FORMATTER_FULL);
//                        LocalDateTime taskTimeTruncateds = taskTimes.truncatedTo(ChronoUnit.MINUTES);
//                                List<TInfoGuidePublish> tasks = filterTasksByTime(basePublishList, todayDateStr, taskTimeTruncateds);
//                               log.error("需要执行任务数量：{}", tasks.size());
//                               log.error("需要执行任务：{}", tasks);
//                               for (TInfoGuidePublish taske : tasks) {
//                                   result.add(taske);
//                               }
//                    }
//                } else {
//                    log.error("任务[{}]不符合时间范围：当前时间[{}]不在[{} - {}]之间",
//                            task.getId(),
//                            currentTimeTruncated.format(DATE_TIME_FORMATTER_FULL),
//                            taskTimeTruncated.format(DATE_TIME_FORMATTER_FULL),
//                            endTimeTruncated.format(DATE_TIME_FORMATTER_FULL));
//                }
            } catch (Exception e) {
                // 这里可以添加异常处理逻辑
                log.error("处理任务[{}]时间时发生错误", task.getId(), e);
            }
        }
        if (!tInfoGuidePublisheShou.isEmpty()){
            tInfoGuidePublisheShou = tInfoGuidePublisheShou.stream()
                    .collect(Collectors.toMap(
                            TInfoGuidePublish::getId, // 以id为键
                            Function.identity(),      // 以对象本身为值
                            (existing, replacement) -> existing // 重复时保留第一个
                    ))
                    .values()
                    .stream()
                    .collect(Collectors.toList());
            return tInfoGuidePublisheShou;
        }
        if (!resultZi.isEmpty()){
            resultZi = resultZi.stream()
                    .collect(Collectors.toMap(
                            TInfoGuidePublish::getId, // 以id为键
                            Function.identity(),      // 以对象本身为值
                            (existing, replacement) -> existing // 重复时保留第一个
                    ))
                    .values()
                    .stream()
                    .collect(Collectors.toList());
            return resultZi;
        }
           return null;
    }

    /**
     * 子方法：补全时间为 HH:mm:ss 格式（兼容 HH、HH:mm、HH:mm:ss，新增非法片段校验）
     *
     * @param startTimeScale 原始时间字符串（如 "12"、"12:30"、"12:30:45"）
     * @return 标准 HH:mm:ss 格式时间
     * @throws IllegalArgumentException 非法时间格式时抛出
     */
    private String 补全时间(String startTimeScale) {
        // 1. 分割时间片段，同时过滤空字符串（处理 "12::07" 这类多冒号的情况）
        String[] timeParts = Arrays.stream(startTimeScale.split(":"))
                .filter(StringUtils::isNotEmpty)
                .toArray(String[]::new);

        // 2. 校验分割后的片段数量（只能是 1、2、3 个）
        if (timeParts.length < 1 || timeParts.length > 3) {
            throw new IllegalArgumentException("时间片段数量非法（需1-3个）：" + startTimeScale);
        }

        // 3. 校验每个片段是否为合法数字，且符合时间范围（HH:0-23, mm/ss:0-59）
        int hour = parseAndValidateTimePart(timeParts[0], 0, 23, "小时", startTimeScale);
        int minute = 0;
        int second = 0;

        // 处理分钟（片段数量>=2时）
        if (timeParts.length >= 2) {
            minute = parseAndValidateTimePart(timeParts[1], 0, 59, "分钟", startTimeScale);
        }

        // 处理秒（片段数量=3时）
        if (timeParts.length == 3) {
            second = parseAndValidateTimePart(timeParts[2], 0, 59, "秒", startTimeScale);
        }

        // 4. 格式化为标准 HH:mm:ss（补前导零，确保2位）
        return String.format("%02d:%02d:%02d", hour, minute, second);
    }

    /**
     * 辅助方法：解析时间片段并校验范围（避免重复代码）
     *
     * @param part     时间片段（如 "12"、"30"）
     * @param min      最小值（如小时0，分钟0）
     * @param max      最大值（如小时23，分钟59）
     * @param partName 片段名称（用于错误提示，如 "小时"、"分钟"）
     * @param original 原始时间字符串（用于错误提示）
     * @return 解析后的整数
     * @throws IllegalArgumentException 非法数字或超出范围时抛出
     */
    private int parseAndValidateTimePart(String part, int min, int max, String partName, String original) {
        int value;
        try {
            // 解析为整数（处理 "08" 这类带前导零的情况，Integer.parseInt 会自动转为8，不影响）
            value = Integer.parseInt(part);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException(
                    String.format("时间%s包含非法数字（%s）：%s", partName, part, original), e);
        }

        // 校验范围
        if (value < min || value > max) {
            throw new IllegalArgumentException(
                    String.format("时间%s超出范围（需%d-%d）：%s", partName, min, max, original));
        }
        return value;
    }

    private final BlockingQueue<ProducerQest> dataQueue = new ArrayBlockingQueue<>(10);

    /**
     * 子方法：检查设备状态并执行发布
     */
    private void checkQianFengDeviceAndPublish(TInfoGuidePublish task) throws Exception {
        log.error("开始乾丰的自动发布业务流程");
//        log.info("开始发布，任务ID：{}", task.getId());
//
//        // 1. 基础参数校验（确保发布详情不为空，避免后续空指针）
//        if (task == null || StringUtils.isEmpty(task.getPublishDetail())) {
//            log.error("任务[{}]：发布详情为空，终止发布", task.getId());
//            throw new IllegalArgumentException("任务发布详情不能为空");
//        }
//
//        // 2. 查询乾丰上位机网络配置（保留原有逻辑）
//        TInfoNetworkConfig networkConfig = infoNetworkConfigService.selectByGuideType(1);
//        if (networkConfig == null) {
//            log.error("任务[{}]：未查询到网络配置信息，终止发布", task.getId());
//            throw new RuntimeException("未查询到网络配置信息");
//        }
//        String deviceIp = networkConfig.getIp();
//        Integer devicePort = networkConfig.getPort();
//        log.info("任务[{}]：获取到设备IP：{}，端口：{}", task.getId(), deviceIp, devicePort);
//
//        // 3. 解析发布详情中的IP列表（对应你提供的data数组）
//        JSONArray originalIpArray = JSONArray.parseArray(task.getPublishDetail());
//        int totalIpCount = originalIpArray.size();
//        int batchSize = 1; // 每批发送5个IP
//        int totalBatches = (totalIpCount + batchSize - 1) / batchSize; // 向上取整算总批次
//        log.info("任务[{}]：待发送IP总数：{}，每批{}个，共需发送{}批",
//                task.getId(), totalIpCount, batchSize, totalBatches);
//
//        // 4. 循环分批发送IP
//        for (int i = 0; i < totalBatches; i++) {
//            // 4.1 计算当前批次的IP索引范围（避免越界）
//            int startIdx = i * batchSize;
//            int endIdx = Math.min((i + 1) * batchSize, totalIpCount);
//            // 4.2 截取当前批次的IP子数组
//            JSONArray batchIpArray = new JSONArray();
//            for (int j = startIdx; j < endIdx; j++) {
//                batchIpArray.add(originalIpArray.get(j));
//            }
//            log.info("任务[{}]：处理第{}/{}批，IP范围：索引{}~{}，当前批IP数量：{}",
//                    task.getId(), i + 1, totalBatches, startIdx, endIdx - 1, batchIpArray.size());
//
//            // 4.3 构建当前批次的请求参数（匹配你提供的参数格式：user、pwd、cmd、data）
//            JSONObject batchParam = new JSONObject();
//            batchParam.put("user", networkConfig.getUsername()); // 沿用配置中的用户名
//            batchParam.put("pwd", networkConfig.getPassword()); // 沿用配置中的密码
//            batchParam.put("cmd", "2"); // 注意：你的参数中cmd为"2"，需与原有逻辑确认是否需要动态调整
//            batchParam.put("data", batchIpArray); // 传入当前批次的IP子数组
//
//            // 4.4 发送当前批次并获取结果
//            String batchResult = qianFengPlayLedService.controlLed(deviceIp, devicePort, batchParam.toJSONString());
//            log.info("任务[{}]：第{}/{}批发送结果：{}", task.getId(), i + 1, totalBatches, batchResult);
//
//            // 4.5 解析结果并处理（保留原有校验逻辑，适配分批场景）
//            JSONObject resultJson = JSONObject.parseObject(batchResult);
//            if (resultJson == null) {
//                log.warn("任务[{}]：第{}/{}批 - 设备IP[{}]状态异常（返回结果为空），跳过该批状态更新",
//                        task.getId(), i + 1, totalBatches, deviceIp);
//                continue;
//            }
//
//            String code = resultJson.getString("code");
//            if (!"0".equals(code)) {
//                log.warn("任务[{}]：第{}/{}批 - 设备IP[{}]状态异常（code={}），跳过该批状态更新",
//                        task.getId(), i + 1, totalBatches, deviceIp, code);
//                continue;
//            }
//
//            // 4.6 批次发送成功后，更新该批IP对应的情报板状态
//            tInfoGuideStatusService.updateGuideStatus(batchIpArray.toJSONString());
//            log.info("任务[{}]：第{}/{}批 - IP情报板状态更新完成", task.getId(), i + 1, totalBatches);
//
//            // 4.7 可选：添加批次间隔，避免设备短时间内处理压力过大
//            try {
//                Thread.sleep(300); // 300毫秒间隔，可根据设备性能调整
//            } catch (InterruptedException e) {
//                Thread.currentThread().interrupt();
//                log.warn("任务[{}]：第{}/{}批 - 批次间隔线程被中断", task.getId(), i + 1, totalBatches, e);
//            }
//        }
//
//        log.info("任务[{}]：所有{}批IP数据发布处理完成", task.getId(), totalBatches);
//        if (task == null || StringUtils.isEmpty(task.getPublishDetail())) {
//            throw new IllegalArgumentException("参数为空");
//        }
//        // 查询乾丰上位机网络配置
//        TInfoNetworkConfig networkConfig = infoNetworkConfigService.selectByGuideType(1);
//        networkConfig.setIp("172.20.147.142");
//        networkConfig.setPort(5225);
//        if (networkConfig == null) {
//            throw new RuntimeException("未查询到网络配置信息");
//        }
//        log.error("自动发布：{}"+networkConfig);
//        JSONObject param = new JSONObject();
//        param.put("user", networkConfig.getUsername());
//        param.put("pwd", networkConfig.getPassword());
//        param.put("cmd", "1");
//        // 先解析原始长数组，后续分批使用
//        JSONArray originalPublishDetail = JSONArray.parseArray(task.getPublishDetail());
//        param.put("data", originalPublishDetail); // 原param保留，不影响其他逻辑
//
////        ProducerQest producerQest = new ProducerQest();
////        producerQest.setTask(task);
////        producerQest.setParam(param);
////        producerQest.setNetworkConfig(networkConfig);
////        producerQest.setIpList(originalPublishDetail.toJSONString());
////        producerQest.setIpListSize((int) originalPublishDetail.size());
////        dataQueue.put(producerQest);
//
//        // 4. 发送当前批次并校验结果
//        String batchResult = qianFengPlayLedService.controlLed(
//                            networkConfig.getIp(),
//                            networkConfig.getPort(),
//                param.toJSONString()
//        );
//        log.error("自动发布结果：{}"+batchResult);
//        // 6. 批次成功后，更新该批次的情报板状态
//        tInfoGuideStatusService.updateGuideStatus(originalPublishDetail.toJSONString());


        protocolClient.sendAutoPublishData(task);
                }


         //添加自动发布
//        TRecordGuidePublish tGuiGuidePublishRecord = new TRecordGuidePublish();
//        BeanUtils.copyProperties(task, tGuiGuidePublishRecord);
//        tGuiGuidePublishRecord.setGuidePublishId(task.getGuideId());
//        tGuiGuidePublishRecord.setOperateType(0);
//        tGuiGuidePublishRecord.setId(null);
//        recordGuidePublishService.saveTRecordGuidePublish(tGuiGuidePublishRecord);

@Autowired
private ProtocolClient protocolClient;
    /**
     * 判断今天是否是目标日期（节假日/调休/周末）
     */
    private boolean isHolidayOrAdjustedOrWeekend(LocalDate today, String todayDateStr, List<THolidaysDate> holidaysList) {
        // 情况1：周六/周日
        DayOfWeek dayOfWeek = today.getDayOfWeek();
        boolean isWeekend = dayOfWeek == DayOfWeek.SATURDAY || dayOfWeek == DayOfWeek.SUNDAY;

        // 情况2：节假日
        boolean isHoliday = isTodayHoliday(todayDateStr, holidaysList);

        // 情况3：调休日
        boolean isAdjustedDay = isTodayAdjustedDay(todayDateStr, holidaysList);

        return isWeekend || isHoliday || isAdjustedDay;
    }


    /**
     * 判断今天是否是节假日（修复：根据字符串长度选择格式器）
     */
    private boolean isTodayHoliday(String todayDateStr, List<THolidaysDate> holidaysList) {
        for (THolidaysDate holiday : holidaysList) {
            String holidayDateTimeStr = holiday.getStartTime();
            if (StringUtils.isEmpty(holidayDateTimeStr)) {
                continue;
            }
            // 提取节假日日期（根据字符串长度选择格式器）
            String holidayDate = extractDateFromDateTimeStr(holidayDateTimeStr);
            if (todayDateStr.equals(holidayDate)) {
                log.info("今天是节假日：{}", todayDateStr);
                return true;
            }
        }
        return false;
    }

    /**
     * 判断今天是否是调休日（修复：根据字符串长度选择格式器）
     */
    private boolean isTodayAdjustedDay(String todayDateStr, List<THolidaysDate> holidaysList) {
        for (THolidaysDate holiday : holidaysList) {
            String adjustedTime = holiday.getAdjustedTime();
            if (StringUtils.isEmpty(adjustedTime)) {
                continue;
            }
            // 处理逗号分隔的多个调休日期
            String[] adjustedDateTimeStrs = adjustedTime.split(",");
            for (String dateTimeStr : adjustedDateTimeStrs) {
                String adjustedDate = extractDateFromDateTimeStr(dateTimeStr);
                if (todayDateStr.equals(adjustedDate)) {
                    log.info("今天是调休日：{}", todayDateStr);
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 修复：根据字符串长度选择格式器（避免解析短格式报错）
     * - 长度10：仅年月日（yyyy-MM-dd）→ 用 DATE_TIME_FORMATTER_DATE_ONLY
     * - 长度19：完整时分秒（yyyy-MM-dd HH:mm:ss）→ 用 DATE_TIME_FORMATTER_FULL
     */
    private String extractDateFromDateTimeStr(String dateTimeStr) {
        if (StringUtils.isEmpty(dateTimeStr)) {
            log.warn("时间字符串为空，跳过解析");
            return "";
        }
        try {
            LocalDate date;
            if (dateTimeStr.length() == 10) {
                // 仅年月日（如 "2025-08-29"）
                date = LocalDate.parse(dateTimeStr, DATE_TIME_FORMATTER_DATE_ONLY);
            } else if (dateTimeStr.length() == 19) {
                // 完整时分秒（如 "2025-08-29 00:00:00"）
                LocalDateTime dateTime = LocalDateTime.parse(dateTimeStr, DATE_TIME_FORMATTER_FULL);
                date = dateTime.toLocalDate();
            } else {
                log.warn("时间字符串长度异常（既非10也非19）：{}", dateTimeStr);
                return "";
            }
            return date.format(DATE_FORMATTER);
        } catch (Exception e) {
            // 兜底：直接截取前10位（避免解析失败导致整个流程中断）
            log.warn("时间字符串解析失败，尝试截取前10位：{}，错误：{}", dateTimeStr, e.getMessage());
            return dateTimeStr.length() >= 10 ? dateTimeStr.substring(0, 10) : "";
        }
    }

    /**
     * 从Redis获取节假日列表（保持不变）
     */
    public List<THolidaysDate> getHolidaysListFromRedis() {
        try {

            LambdaQueryWrapper<THolidaysDate> tHolidaysDateLambdaQueryWrapper = new LambdaQueryWrapper<>();
            tHolidaysDateLambdaQueryWrapper.eq(THolidaysDate::getDelFlg, 0);
            List<THolidaysDate> list1 = tHolidaysDateService.list(tHolidaysDateLambdaQueryWrapper);

//        Object result = redisTemplate.opsForValue().get(THolidaysDateKey.KEY_HOLIDAYS_ALL);
            if (list1 instanceof List<?>) {
                List<?> list = (List<?>) list1;
                if (list.isEmpty() || list.get(0) instanceof THolidaysDate) {
                    return (List<THolidaysDate>) list;
                }
                log.warn("Redis中节假日数据元素类型不符，预期THolidaysDate");
            } else {
                log.warn("Redis中未找到有效节假日数据（非List类型）");
            }
        } catch (Exception e) {
            log.error("从Redis获取节假日数据失败", e);
        }
        return List.of();
//            try {
//                // 从Redis获取数据
//                Object result = redisTemplate.opsForValue().get(THolidaysDateKey.KEY_HOLIDAYS_ALL);
//
//                // 判断Redis中的数据是否为空
//                if (result == null) {
//                    log.info("Redis中未找到节假日数据，key: KEY_HOLIDAYS_ALL");
//                    // 返回空列表或从数据库获取
//                    return new ArrayList<>();
//                }
//
//                // 检查数据类型并转换
//                if (result instanceof List<?>) {
//                    List<?> list = (List<?>) result;
//                    if (list.isEmpty()) {
//                        log.info("Redis中节假日数据为空列表");
//                        return new ArrayList<>();
//                    }
//                    // 类型安全检查
//                    if (list.get(0) instanceof THolidaysDate) {
//                        return (List<THolidaysDate>) list;
//                    } else {
//                        log.warn("Redis中节假日数据元素类型不符，预期THolidaysDate");
//                        return new ArrayList<>();
//                    }
//                } else {
//                    log.warn("Redis中数据不是List类型");
//                    return new ArrayList<>();
//                }
//            } catch (Exception e) {
//                log.error("从Redis获取节假日数据失败", e);
//                // 异常情况下返回空列表或从数据库获取
//                return new ArrayList<>();
//            }
        }


}